home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / tex / tools / dvi_300b / treiber / sources / bj200.c < prev    next >
C/C++ Source or Header  |  1995-11-25  |  17KB  |  480 lines
  1. /*
  2.         Treiber für Canon BJ200 Drucker für Atari DVI-Treiber (Version 2.30):
  3.         Für Quer- und Hochkant!
  4.  
  5.         - DVI-Druckertreiber für Canon BJ200 Drucker. Der Sourcecode entspricht
  6.             (immer noch) gröβtenteils der EPSON-Stylus Version. 
  7.  
  8.         - WICHTIG: Dieser Treiber erwartet das der Canon BJ in der
  9.                                             ____BJ-Emulation____
  10.             betrieben wird! Für die EPSON-Emulation kann man den EPSON LQ800
  11.             Treiber benutzen. Letzterer bietet nur keine echten 360*360 dpi
  12.             Auflösung (Eine Nadel wird in der EPSON-Emulation immer durch zwei
  13.             Düsen emuliert) und auch keinen 48 Düsen Druck :-(.
  14.  
  15.         - Bemerkung: Ich habe diesen Treiber nur teilweise getestet!
  16.                                  (Nicht nur) Deshalb:
  17.  
  18.             BENUTZUNG AUF EIGENE GEFAHR. ICH ÜBERNEHME KEINE VERANTWORTUNG
  19.             FÜR EVENTUELLE SCHÄDEN, DIE DURCH DIE BENUTZUNG DIESES TREIBERS
  20.             VERURSACHT WURDEN. ICH BEHAUPTE AUCH NICHT, DASS DIESES PROGRAMM
  21.             IRGENDEINEN ZWECK ERFÜLLT.
  22.             WER HIERMIT NICHT EINVERSTANDEN IST, DARF DIESEN TREIBER NICHT
  23.             BENUTZEN!!
  24.  
  25.             Verbesserungsvorschläge sind willkommen:
  26.  
  27.             Derzeitige Adresse:
  28.             
  29.             Dietmar Herrendörfer,
  30.             Department of Physics,
  31.             Trinity College,
  32.             Dublin 2
  33.             Ireland
  34.             email: dhrrndrf@tcd.ie
  35.             
  36.         - Version 1.2
  37.  
  38.         © 1995, Dietmar Herrendörfer.
  39.         © Markus Pristovsek, für die Teile, die aus anderen Treibern wurden.
  40.         
  41.         Bem.: Tabulatorabstand auf 4 Zeichen setzen.
  42. */
  43.  
  44. /* Weitere Bemerkung: Der Treiber wurde von mir (Markus Pristovsek) in neue Form 
  45. eingepaßt. Theoretisch sollte er funktionieren, kann jedoch von mir mangels Drucker 
  46. nicht getestet werden. */
  47.  
  48. #include <limits.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51. #include <portab.h>
  52. #include "treiber.h"
  53.  
  54.  
  55.  
  56. /*** Ein paar Parameter: ***/
  57. /*++ Seitenabmessungen - alle Pixelgröβen bezogen auf 360dpi*360dpi: ++*/
  58. #define TOP                 43L                                                         /* Oberer Rand in Pixeln. */
  59. #define BOTTOM            90L                                                         /* Unterer Rand in Pixeln. */
  60. #define LEFT                47L                                                         /* Linker Rand in Pixeln. */
  61. #define RIGHT             49L                                                         /* Rechter Rand in Pixel. */
  62. #define A4WIDTH         2976L                                                     /* A4 Papierbreite in Pixeln. */
  63. #define A4HEIGHT        4209L                                                     /* A4 Papierhöhe in Pixeln. */
  64. #define WIDTH             (A4WIDTH-LEFT-RIGHT)                        /* max. Breite einer Grafikseite */
  65. #define HEIGHT            (A4HEIGHT-TOP-BOTTOM)                     /* max. Bitmap Höhe */
  66. #define BUF_SIZE        WIDTH*6L+6L+256L                                /* Gröβe des benötigten Zeilenpuffers. */
  67.  
  68. /*** Neudefinierte Typen: ***/
  69. typedef struct {
  70.     UBYTE     id;                                                 /* Druckmodusnummer. */
  71.     WORD        h_dpi;                                            /* Horizontale Auflösung. */
  72.     WORD        v_dpi;                                            /* Vertikale Auflösung. */
  73.     WORD        bytes;                                            /* Bytes pro Druckkopf-Spalte. */
  74. } MODI;
  75.  
  76. /*** Lokale Variablen: ***/
  77. /*++ Drucker Steuercodes und ähnliches Druckerspezifisches: ++*/
  78. static UBYTE        init[]        = "\033[K\002\000\000\045"/* Reset & 1/360 dpi spacing. */
  79.                                                         "\033[\\\004\000\000\000\150\001";
  80. static UBYTE        h_step[]    = "\033d__";                            /* Horizontale Druckkopfbewegung. */
  81. static UBYTE        v_step[]    = "\034CJ\004_\015";            /* Zeilenvorschub in 360 dpi. */
  82. static UBYTE        v_skip[]    = "\034CJ\000\200\015";     /* 256/360 Inch Zeilenvorschub. */
  83. static UBYTE        g_print[] = "\033[g";                             /* Bitmap-Graphik drucken. */
  84. static MODI         cbj_mode[]= {{    0,    60,  60, 1},        /* Canon BJ200 Druckermodi: */
  85.                                                          {    1, 120,  60, 1},
  86.                                                          {    2, 120,  60, 1},
  87.                                                          {    3, 240,  60, 1},
  88.                                                          {    8,    60, 180, 3},
  89.                                                          {    9, 120, 180, 3},
  90.                                                          { 11, 180, 180, 3},
  91.                                                          { 12, 360, 180, 3},
  92.                                                          { 13, 120, 360, 6},
  93.                                                          { 14, 180, 360, 6},
  94.                                                          { 15, 240, 360, 6},
  95.                                                          { 16, 360, 360, 6},
  96.                                                          {    0,     0,     0, 0}};     /* Markiert das Listenende !*/
  97.  
  98. /****************************************************************************************/
  99.  
  100. /*** Globale Variablen: ***/
  101. LONG    max_puffer_laenge = BUF_SIZE;     /* Obergrenze der Gröβe des Druckpuffers. */
  102.  
  103. /*** Lokale Variable: ***/
  104. static UBYTE        prt_buffer[BUF_SIZE];                             /* Zwischenspeicher für eine Zeile */
  105.  
  106.  
  107. /* Überspringt "Rows" leerzeilen */
  108. void    skip_rows( WORD out_channel, LONG rows )
  109. {
  110.     v_step[4] = (UBYTE)255;    /* Maximal 255 Zeilen pro Vorschub: */
  111.     while(  rows>255L  )
  112.     {
  113.         print_block( 6L, v_step, out_channel );
  114.         rows -= 255L;
  115.     }
  116.     v_step[4] = (UBYTE)rows;    /* und den Rest */
  117.     print_block( 6L, v_skip, out_channel );
  118. }
  119. /* 7.10.95 */
  120.  
  121.  
  122. /****************************************************************************************/
  123. /* Ausdruck einer Seite als Landscape */
  124.  
  125. WORD drucke_quer(UBYTE *bitmap_ptr, LONG h_offset, LONG hsize_p, LONG vsize_p, LONG h_dpi, LONG v_dpi, WORD out_channel, WORD flag )
  126. {
  127.     UBYTE                    *bit_ptr, *prt_ptr;                /* Pointer in die Bitmap und in den Druckpuffer. */
  128.     MODI                    *mode, *tmp_mode;                    /* Zeiger auf die Modus-Tabelle. */
  129.     LONG                    hdpi_diff, vdpi_diff;            /* Zum Festlegen der Auflösung. */
  130.     register LONG    tmp;                                            /* Puffer für alles mögliche. */
  131.     register LONG    hsize_b, hsize_m;                    /* Druckseitenbreite in Bytes, Bitmapbreite in Bytes. */
  132.     register LONG    h_pos, rows_to_skip;            /* Derzeitige Druck-Zeile, Anzahl leerer Zeilen. */
  133.     LONG                    l_margin, right, left;        /* Linker Rand, Zeilenränder. */
  134.     LONG                    prt_columns, prt_bytes;        /* Druckspalten pro Zeile, Spaltenhöhe in Bytes. */
  135.     int                        active;                                        /* Ein flag. */    
  136.  
  137.     (void)h_offset;    /* ignorieren */
  138.  
  139.     /*** Initialisierung: ***/
  140.     /*++ Gewünschte Auflösung an vorhandene Auflösungen anpassen: ++*/
  141.     /*++ Bem.: Die optimale Anpassung der vertikalen Auflösung geht vor. ++*/
  142.     tmp_mode = cbj_mode;
  143.     hdpi_diff = vdpi_diff = LONG_MAX; /* Zunächst maximale Abweichung. */
  144.     do
  145.     {
  146.         if(  labs( tmp_mode->v_dpi - h_dpi )<hdpi_diff  )
  147.         {
  148.             hdpi_diff = labs(tmp_mode->v_dpi - h_dpi);
  149.             vdpi_diff = labs(tmp_mode->h_dpi - v_dpi);
  150.             mode = tmp_mode;
  151.         }
  152.         if(  labs( tmp_mode->v_dpi - h_dpi )==hdpi_diff  )
  153.         {
  154.             if(  labs( tmp_mode->h_dpi - v_dpi )<vdpi_diff  )
  155.             {
  156.                 mode = tmp_mode;
  157.                 vdpi_diff = labs(tmp_mode->v_dpi - v_dpi);
  158.             }
  159.         }
  160.     }
  161.     while(  (++tmp_mode)->bytes  );    /* bytes == 0 => Ende. */
  162.     h_dpi = mode->v_dpi;                                /* Auflösung ggf. abändern. */
  163.     v_dpi = mode->h_dpi;
  164.     prt_bytes = mode->bytes;
  165.  
  166.     /*++ Diverse Variablen setzen: ++*/
  167.     strcpy(prt_buffer, g_print);                        /* Bitmap-Graphik Steuerkode kopieren */
  168.  
  169.     hsize_b = (hsize_p < (HEIGHT*h_dpi)/360L) ? (hsize_p + 7L) >> 3 : (HEIGHT*h_dpi)/2880L;
  170.     hsize_m = ((hsize_p + 15L) >> 4) << 1;                /* -> die 'Bitmap' ist eine gerade Anzahl von Bytes hoch. */
  171.  
  172.     /* Nicht druckbare Ränder überspringen. */
  173.     if(  flag&1  )
  174.     {
  175.         bitmap_ptr += (tmp = (((TOP*v_dpi)/360L + 7L) >> 3)) - hsize_m*((LEFT*h_dpi)/360L);
  176.         hsize_b -= tmp;        /* vertikale Gröβe entsprechend korrigieren. */
  177.     }
  178.  
  179.     /* Breite der Seite überprüfen: */
  180.     if(  vsize_p>(tmp = (WIDTH*v_dpi)/360L)  )
  181.         vsize_p = tmp;
  182.  
  183.     
  184.     /*++ Testen ob die Seite leer ist: ++*/
  185.     rows_to_skip = 0;        /* Zunächst keine leeren Zeilen. */
  186.     for(  l_margin=0;  
  187.           ist_next_leer( bitmap_ptr + l_margin, hsize_m, vsize_p)  &&  l_margin < hsize_b; 
  188.           l_margin++  )
  189.       ;
  190.     /* Leere Druckzeile ? */
  191.     if(  l_margin==hsize_b  )
  192.     {
  193.         rows_to_skip = hsize_m;
  194.         h_pos = hsize_m;
  195.     }
  196.  
  197.     /*** Begin des Druckvorgangs: ***/
  198.     /*++ Reset: ++*/
  199.     if (flag & 1)
  200.         print_block( 16L, init, out_channel );
  201.     h_pos = 0;
  202.  
  203.     /*++ Bytes im Puffer an den Drucker ausgeben: ++*/
  204.     active = TRUE;
  205.     while(  active  &&  flag&2  )
  206.     {
  207.         /*++ Leerzeilen gesondert abarbeiten: ++*/
  208.         while(  h_pos+rows_to_skip < hsize_m  &&  ist_next_leer( bitmap_ptr + rows_to_skip, hsize_b, vsize_p)  )
  209.             ++rows_to_skip;
  210.         h_pos += rows_to_skip;
  211.         if(  h_pos > hsize_b  )
  212.             rows_to_skip = hsize_b - (h_pos - rows_to_skip);
  213.  
  214.         /* Ist diese Seite ist schon fertig? */
  215.         if(  TRUE == (active = (h_pos < hsize_b))  )
  216.         {
  217.             /* Leerzeilen zu überspringen ? */
  218.             if(  rows_to_skip>0L  )
  219.                 skip_rows( out_channel, (rows_to_skip*2880L)/h_dpi );
  220.  
  221.             /*++ Ränder einstellen: ++*/
  222.             for( right=0;
  223.                  right < vsize_p - 1L  &&  ist_leerzeile(bitmap_ptr + right*hsize_m, prt_bytes);
  224.                  right++  )
  225.               ;
  226.             --right;
  227.  
  228.             for( left = vsize_p - 1L;
  229.                  left > right  &&  ist_leerzeile(bitmap_ptr + left*hsize_m, prt_bytes);
  230.            left--  )
  231.         ;
  232.             ++left;
  233.  
  234.             /* Linker Rand ? */
  235.             if(  left>0  )
  236.             {
  237.                 left = (left/3)*3;            /* Da in (ganzen) 120 dpi Schritten. */
  238.                 tmp = ((vsize_p - left)*120)/v_dpi;
  239.                 h_step[2] = (UBYTE)tmp;
  240.                 h_step[3] = (UBYTE)(tmp >> 8);
  241.                 print_block(4L, h_step, out_channel);
  242.             }
  243.  
  244.             /*++ Daten drucken: ++*/
  245.             prt_ptr = prt_buffer + 6;
  246.             for(  prt_columns=left-right;  prt_columns!=0;  prt_columns--  )
  247.             {
  248.                 bit_ptr = bitmap_ptr+(prt_columns)*hsize_m;
  249.                 for(  tmp=1; tmp<=prt_bytes; tmp++  )
  250.                     *prt_ptr++ = *bit_ptr++;
  251.             }
  252.             
  253.             prt_columns = left - right;
  254.             prt_buffer[3] = (UBYTE)(prt_columns*prt_bytes + 1L);
  255.             prt_buffer[4] = (UBYTE)((prt_columns*prt_bytes + 1L) >> 8);
  256.             prt_buffer[5] = (UBYTE)mode->id;
  257.  
  258.             /* Überagt Zeile unteren Rand ? */
  259.             if(  h_pos+prt_bytes>hsize_b  )
  260.             {
  261.                 register WORD    bit, byte, and_it;    /*  => Abschneiden. */
  262.  
  263.                 bit = (WORD)(h_pos + prt_bytes - hsize_b);
  264.                 byte = bit >> 3;
  265.                 and_it = (0x00FF << (bit & 7));
  266.                 for(  rows_to_skip=0L;  rows_to_skip<prt_columns*prt_bytes;  rows_to_skip++  )
  267.                 {
  268.                     if(  rows_to_skip%prt_bytes == byte  )
  269.                         prt_buffer[6L + rows_to_skip] &= and_it;
  270.                     else
  271.                         if(  rows_to_skip%prt_bytes > byte  )
  272.                             prt_buffer[6 + rows_to_skip] = 0;
  273.                 }
  274.             }
  275.             print_block( 6L+prt_columns*prt_bytes, prt_buffer, out_channel );
  276.             rows_to_skip = prt_bytes;
  277.             bitmap_ptr += prt_bytes;
  278.         }
  279.     }
  280.  
  281.     /*** Seitenende bearbeiten: ***/
  282.     if (flag & 4)
  283.         print_block(1L, "\014\007", out_channel);
  284.  
  285.     /*** Das war es: ***/
  286.     return 0;
  287. }
  288. /* Änderungen 7.10.95, M. Pristovsek */
  289.  
  290.  
  291. /****************************************************************************************/
  292.  
  293. /***        Druckpuffer ausdrucken (für Querdruck wird drucke_quer aufgerufen):
  294. ****
  295. ****         > bitmap_ptr     (UBYTE *)     ; Puffer mit den zu druckenden Bytes.
  296. ****         > v_offset         (LONG)            ; vertikale (horizontale) Startposition in der Bitmap.
  297. ****         > hsize_p            (LONG)            ; Breite der Bitmap in Pixeln.
  298. ****         > vsize_p            (LONG)            ; Höhe der Bitmap in Pixeln.
  299. ****         > h_dpi                (LONG)            ; gewünschte horizontale Auflösung.
  300. ****         > v_dpi                (LONG)            ; gewünschte vertikale Auflösung.
  301. ****         > out_channel    (WORD)            ; Ausgabekanal (siehe TOS: 'Fopen')
  302. ****         > flag                 (WORD)            ; Bitfeld: 1=Header, 2=Daten, 4=Ende
  303. ****         > quer                    (WORD)            ; Querdruck
  304. ****         > opt                    (UBYTE *)        ; String mit zus. Optionen (max. 16 Bytes)
  305. ***/
  306.  
  307. WORD drucke( UBYTE *bitmap_ptr, LONG v_offset, LONG hsize_p, LONG vsize_p,
  308.                          LONG h_dpi, LONG v_dpi, WORD out_channel, WORD flag, WORD quer, UBYTE *opt )
  309. {
  310.     /*** Lokale Variablen: ***/
  311.     MODI                    *mode, *tmp_mode;             /* Zeiger auf die Modus-Tabelle. */
  312.     LONG                    hdpi_diff, vdpi_diff;     /* Zum Festlegen der Auflösung. */
  313.     register LONG tmp;                                        /* Puffer für alles mögliche. */
  314.     register LONG hsize_b, hsize_m;             /* Druckseitenbreite in Bytes, Bitmapbreite in Bytes. */
  315.     register LONG v_pos, rows_to_skip;        /* Derzeitige Druck-Zeile, Anzahl leerer Zeilen. */
  316.     LONG                    l_margin, right, left;    /* Linker Rand, Zeilenränder. */
  317.     LONG                    prt_columns, prt_bits;    /* Druckspalten pro Zeile, Spaltenhöhe in Bits. */
  318.     int                     active;                                 /* Ein flag. */
  319.  
  320.     (void)opt;    /* ignorieren */
  321.     if(  quer  )
  322.         return drucke_quer( bitmap_ptr, v_offset, hsize_p, vsize_p, h_dpi, v_dpi, out_channel, flag );
  323.  
  324.     /*** Initialisierung: ***/
  325.  
  326.     /*++ Gewünschte Auflösung an vorhandene Auflösungen anpassen: ++*/
  327.     /*++ Bem.: Die optimale Anpassung der horizontalen Auflösung geht vor. ++*/
  328.     tmp_mode = cbj_mode;
  329.     hdpi_diff = vdpi_diff = LONG_MAX; /* Zunächst maximale Abweichung. */
  330.     do
  331.     {
  332.         if(  labs( tmp_mode->h_dpi - h_dpi )<hdpi_diff  )
  333.         {
  334.             hdpi_diff = labs(tmp_mode->h_dpi - h_dpi);
  335.             vdpi_diff = labs(tmp_mode->v_dpi - v_dpi);
  336.             mode = tmp_mode;
  337.         }
  338.         if(  labs( tmp_mode->h_dpi - h_dpi )==hdpi_diff  )
  339.         {
  340.             if(  labs( tmp_mode->v_dpi - v_dpi )<vdpi_diff  )
  341.             {
  342.                 mode = tmp_mode;
  343.                 vdpi_diff = labs(tmp_mode->v_dpi - v_dpi);
  344.             }
  345.         }
  346.     }
  347.     while(  (++tmp_mode)->bytes  );    /* bytes == 0 => Ende. */
  348.     h_dpi = mode->h_dpi;                        /* Auflösung ggf. abändern. */
  349.     v_dpi = mode->v_dpi;
  350.     prt_bits = mode->bytes << 3;
  351.  
  352.     /*++ Diverse Variablen setzen: ++*/
  353.     strcpy(prt_buffer, g_print);    /* Bitmap-Graphik Steuerkode kopieren */
  354.  
  355.     hsize_b = (hsize_p < (WIDTH*h_dpi)/360L) ? (hsize_p + 7L) >> 3 : (WIDTH*h_dpi)/2880L;
  356.     hsize_m = ((hsize_p + 15L) >> 4) << 1;        /* -> die 'Bitmap' ist eine gerade Anzahl von Bytes weit. */
  357.     if(  flag&1  )
  358.     {                                                                                 /* Nicht druckbare Ränder überspringen. */
  359.         bitmap_ptr += hsize_m*(tmp = (TOP*v_dpi)/360L) + (((LEFT*h_dpi)/360L + 7L) >> 3);
  360.         vsize_p -= tmp;                                                 /* vertikale Gröβe entsprechend korrigieren. */
  361.     }
  362.  
  363.     v_pos = v_offset;
  364.     vsize_p += v_offset;        /* Höhe der Seite überprüfen: */
  365.     if(  vsize_p > (tmp = (HEIGHT*v_dpi)/360L)  )
  366.         vsize_p = tmp;
  367.     vsize_p -= v_offset;
  368.     --vsize_p;
  369.     
  370.  
  371.     /*++ Testen ob die Seite leer ist: ++*/
  372.     for (l_margin = 0; ist_next_leer(bitmap_ptr + l_margin, hsize_m, vsize_p)  &&  l_margin < hsize_b; l_margin++);
  373.     rows_to_skip = 0;                                         /* Zunächst keine leeren Zeilen. */
  374.     if(  l_margin == hsize_b  )
  375.     {    /* Leere Druckseite ? */
  376.         rows_to_skip = vsize_p - v_pos;     /* So tun, als ob das Ende der Seite erreicht ist. */
  377.         v_pos = vsize_p;
  378.     }
  379.  
  380.  
  381.     /*** Begin des Druckvorgangs: ***/
  382.     /*++ Reset: ++*/
  383.     if(  flag&1  )
  384.         print_block(16L, init, out_channel);
  385.  
  386.     /*++ Bytes im Puffer an den Drucker ausgeben: ++*/
  387.     active = TRUE;
  388.     while(  active  &&  v_pos<vsize_p  &&  flag&2  )
  389.     {
  390.         /*++ Leerzeilen gesondert abarbeiten: ++*/
  391.         while(  v_pos < vsize_p  &&  ist_leerzeile(bitmap_ptr, hsize_b)  )
  392.         {
  393.             rows_to_skip++;
  394.             v_pos++;
  395.             bitmap_ptr += hsize_m;
  396.         }
  397.  
  398.         /* Ist diese Seite ist schon fertig? */
  399.         if(  TRUE==(active=(v_pos<vsize_p))  )
  400.         {
  401.             /* Leerzeilen zu überspringen ? */
  402.             if(  rows_to_skip!=0L  )
  403.                 skip_rows( out_channel, (rows_to_skip*360L)/v_dpi );
  404.  
  405.             /*++ Ränder einstellen: ++*/
  406.             for(  right=hsize_b - 1L;
  407.                       right > l_margin  &&  ist_next_leer(bitmap_ptr + right, hsize_m, prt_bits);
  408.                         right--  )
  409.                 ;
  410.             ++right;
  411.  
  412.             for(  left=l_margin;
  413.                         ist_next_leer(bitmap_ptr + left, hsize_m, prt_bits) && left < right;
  414.                         left++  )
  415.                 ;
  416.             /* Linker Rand ? */
  417.             if(  left>0  )
  418.             {
  419.                 left = (left/3)*3;                            /* Da in (ganzen) 120 dpi Schritten. */
  420.                 tmp = ((left << 3)*120)/h_dpi;
  421.                 h_step[2] = (UBYTE)tmp;
  422.                 h_step[3] = (UBYTE)(tmp >> 8);
  423.                 print_block( 4L, h_step, out_channel );
  424.             }
  425.             prt_columns = right - left;
  426.  
  427.             /*++ Daten drucken: ++*/
  428.             block_it( prt_buffer+6L, bitmap_ptr+left, prt_columns, hsize_m, mode->bytes );
  429.             prt_buffer[3] = (UBYTE)(prt_columns*prt_bits + 1L);
  430.             prt_buffer[4] = (UBYTE)((prt_columns*prt_bits + 1L) >> 8);
  431.             prt_buffer[5] = (UBYTE)mode->id;
  432.  
  433.             /* Überagt Zeile unteren Rand ? */
  434.             if (v_pos + prt_bits > vsize_p)
  435.             {
  436.                 register WORD     bit, byte, and_it;    /*    => Abschneiden. */
  437.  
  438.                 bit = (WORD)(v_pos + prt_bits - vsize_p);
  439.                 byte = bit >> 3;
  440.                 and_it = (0x00FF << (bit & 7));
  441.                 for(  rows_to_skip = 0L;  rows_to_skip < prt_columns*prt_bits;  rows_to_skip++  )
  442.                 {
  443.                     if(  rows_to_skip%mode->bytes == byte  )
  444.                         prt_buffer[6L + rows_to_skip] &= and_it;
  445.                     else
  446.                         if(  rows_to_skip%mode->bytes > byte  )
  447.                             prt_buffer[6 + rows_to_skip] = 0;
  448.                 }
  449.                 print_block( 6L+prt_columns*prt_bits, prt_buffer, out_channel);
  450.                 rows_to_skip = bit;
  451.                 active = FALSE;
  452.             }
  453.             else
  454.             {
  455.                 rows_to_skip = prt_bits;
  456.                 print_block( 6L+prt_columns*prt_bits, prt_buffer, out_channel );
  457.                 bitmap_ptr += hsize_m * prt_bits;
  458.                 v_pos += rows_to_skip;
  459.             }
  460.         }
  461.     }
  462.  
  463.     /*** Seitenende bearbeiten: ***/
  464.     /* Seite beenden ? */
  465.     if(  flag&4  )
  466.         print_block( 1L, "\014\007", out_channel );
  467.     else
  468.     {
  469.         /* Evt. Rest ausgeben: Nur noch Leerzeilen */
  470.         /* Leerzeilen zu überspringen ? */
  471.         if(  rows_to_skip != 0L  )
  472.             skip_rows( out_channel, (rows_to_skip*360L)/v_dpi );
  473.     }
  474.  
  475.     /*** Das war es: ***/
  476.     flush_block( out_channel );
  477.     return 0; /* Fehler sind nicht vorgesehen. */
  478. }
  479. /* Änderungen 7.10.95, M. Pristovsek */
  480.